package com.ryh.shiro.redis;

import com.ryh.util.RedisUtil;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.util.SerializationUtils;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * @ClassName RedisSessionDao
 * @Description 通过redis实现session共享
 * @Author RaoYH
 */
public class RedisSessionDao extends AbstractSessionDAO {

    private final String SESSION_PREFIX = "shiroSession:";

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 因为在redis中是以二进制的方式进行存储
     */
    private byte[] getKey(String key) {

        return (SESSION_PREFIX + key).getBytes();
    }

    /**
     * 创建session
     *
     * @param session
     * @return
     */
    @Override
    protected Serializable doCreate(Session session) {
        //先通过generateSession来获取sessionId
        Serializable sessionId = generateSessionId(session);
        //将session和sessionId进行绑定
        assignSessionId(session, sessionId);
        saveSession(session);

        return sessionId;
    }

    /**
     * 保存session
     *
     * @param session
     */
    private void saveSession(Session session) {
        if (session != null && session.getId() != null) {
            //通过sessionId来保存对应的session。这里在sessionId前添加一个了前缀SESSION_PREFIX
            byte[] key = getKey(session.getId().toString());
            //将session对象序列化为byte数组
            byte[] value = SerializationUtils.serialize(session);
            //存储到缓存中
            redisUtil.set(key, value);
            //设置超时时间, 60秒
            redisUtil.expire(key, 60);
        }
    }

    /**
     * 通过sessionId获取session
     *
     * @param sessionId
     * @return
     */
    @Override
    protected Session doReadSession(Serializable sessionId) {
        System.out.println("readSession ");
        if (sessionId == null) {
            return null;
        }
        byte[] key = getKey(sessionId.toString());
        byte[] value = redisUtil.get(key);
        //判断session是否存在，或者是过期，若不存在则新建
        if (value == null){

        }
        //获取的值是一个byte数组，所以需要进行反序列成session对象
        return (Session) SerializationUtils.deserialize(value);
    }

    /**
     * 更新session,因为redis中如果key存在那么再次存储的话会更新其value
     *
     * @param session
     * @throws UnknownSessionException
     */
    @Override
    public void update(Session session) throws UnknownSessionException {
        saveSession(session);
    }

    /**
     * 删除
     *
     * @param session
     */
    @Override
    public void delete(Session session) {
        if (session != null && session.getId() != null) {
            byte[] key = getKey(session.getId().toString());
            redisUtil.del(key);
        }
    }

    /**
     * 获取指定存活的session
     *
     * @return
     */
    @Override
    public Collection<Session> getActiveSessions() {
        //通过前缀获取所有的key
        Set<byte[]> keys = redisUtil.keys(SESSION_PREFIX);
        Set<Session> sessions = new HashSet<>();
        if (CollectionUtils.isEmpty(keys)){
            return sessions;
        }
        for (byte[] key : keys) {
            Session session = (Session) SerializationUtils.deserialize(redisUtil.get(key));
            sessions.add(session);
        }
        return sessions;
    }
}
